home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / widgets / Signalmgr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-01  |  9.3 KB  |  334 lines
  1. #include <X11/IntrinsicP.h>
  2. #include <X11/StringDefs.h>
  3. #include <X11/Xaw/Label.h>
  4. #include <X11/Xaw/Scrollbar.h>
  5. #include "Signal.h"
  6. #include "SignalmgrP.h"
  7.  
  8. static XtResource resources[] = {
  9.   { XtNscrollbarWidth, XtCDimension, XtRDimension, sizeof(Dimension), 
  10.       XtOffset(SignalmgrWidget, signalmgr.scrollbar_width), XtRImmediate, (XtPointer) 20},
  11.   { XtNlabelWidth, XtCDimension, XtRDimension, sizeof(Dimension), 
  12.       XtOffset(SignalmgrWidget, signalmgr.label_width), XtRImmediate, (XtPointer) 60},
  13.   { XtNlabelHeight, XtCDimension, XtRDimension, sizeof(Dimension), 
  14.       XtOffset(SignalmgrWidget, signalmgr.label_height), XtRImmediate, (XtPointer) 40},
  15.   { XtNoriginChanged, XtCCallback, XtRCallback, sizeof(XtCallbackList),
  16.       XtOffset(SignalmgrWidget, signalmgr.origin_changed), XtRImmediate, NULL},
  17.   { XtNwidgetsShown, XtCWidgetsShown, XtRInt, sizeof(int),
  18.       XtOffset(SignalmgrWidget, signalmgr.widgets_shown), XtRImmediate, (XtPointer) 5},
  19. };
  20.  
  21. void SignalmgrClassPartInitialize();
  22. void SignalmgrInitialize();
  23. XtGeometryResult SignalmgrQueryGeometry();
  24. XtGeometryResult SignalmgrGeometryManager();
  25. void SignalmgrChangeManaged();
  26. void SignalmgrResize();
  27.  
  28. externaldef(signalmgrclassrec) SignalmgrClassRec signalmgrClassRec = {
  29.   { /******* CorePart *******/
  30.     /* superclass        */    (WidgetClass) &compositeClassRec,
  31.     /* class_name        */    "Signalmgr",
  32.     /* widget_size        */    sizeof(SignalmgrRec),
  33.     /* class_initialize     */  NULL,
  34.     /* class_part_initialize*/    SignalmgrClassPartInitialize,
  35.     /* class_inited        */    FALSE,
  36.     /* initialize        */    SignalmgrInitialize,
  37.     /* initialize_hook      */    NULL,        
  38.     /* realize            */    XtInheritRealize,
  39.     /* actions            */    NULL,
  40.     /* num_actions        */    0,
  41.     /* resources        */    resources,
  42.     /* num_resources        */    XtNumber(resources),
  43.     /* xrm_class        */    NULLQUARK,
  44.     /* compress_motion      */    FALSE,
  45.     /* compress_exposure    */    TRUE,
  46.     /* compress_enterleave  */  FALSE,
  47.     /* visible_interest     */    FALSE,
  48.     /* destroy            */    NULL,
  49.     /* resize            */    SignalmgrResize,
  50.     /* expose            */    NULL,
  51.     /* set_values        */    NULL,
  52.     /* set_values_hook      */    NULL,            
  53.     /* set_values_almost    */    XtInheritSetValuesAlmost,  
  54.     /* get_values_hook      */    NULL,            
  55.     /* accept_focus        */    NULL,
  56.     /* version            */    XtVersion,
  57.     /* callback_offsets     */  NULL,
  58.     /* tm_table            */  NULL,
  59.     /* query_geometry        */  NULL, /*SignalmgrQueryGeometry, */
  60.     /* display_accelerator  */    NULL,
  61.     /* extension        */  NULL
  62.   },
  63.   { /**** CompositePart *****/
  64.     /* geometry_handler     */  SignalmgrGeometryManager,
  65.     /* change_managed       */  SignalmgrChangeManaged,
  66.     /* insert_child        */  XtInheritInsertChild,
  67.     /* delete_child        */  XtInheritDeleteChild,
  68.     /* extension        */  NULL
  69.   },
  70.   { /**** SignalmgrPart *****/
  71.     /* mumbojumbo           */  1
  72.   }
  73. };
  74.  
  75. externaldef(signalmgrwidgetclass) WidgetClass signalmgrWidgetClass = (WidgetClass) &signalmgrClassRec;
  76.  
  77. void SignalmgrClassPartInitialize(){};
  78.  
  79. void do_layout();
  80. void try_do_layout();
  81.  
  82. static void Scroll(sw, w, pos)
  83. ScrollbarWidget sw;
  84. SignalmgrWidget w;
  85. XtPointer pos;
  86. {
  87.     if((int)pos > 0){
  88.        w->signalmgr.scroll++;
  89.        do_layout(w);
  90.     } else {
  91.        if(w->signalmgr.scroll>0){
  92.          w->signalmgr.scroll--; 
  93.          do_layout(w);
  94.        }
  95.     }
  96. }
  97.  
  98. static void reset_length_cash(w)
  99. SignalmgrWidget w;
  100. {
  101.     w->signalmgr.signal_length_cash = 0;
  102. }
  103.  
  104. static void update_length_cash(w, signal)
  105. SignalmgrWidget w;
  106. SignalWidget signal;
  107. {
  108.     int i;
  109.     XtVaGetValues(signal,
  110.     XtNsampleLength, &i,
  111.     XtNtimeScale, &(w->signalmgr.time_scale),
  112.     NULL);
  113.     if(w->signalmgr.signal_length_cash < i)w->signalmgr.signal_length_cash = i;
  114. }
  115.  
  116. static int length_cash(w)
  117. SignalmgrWidget w;
  118. {
  119.      return w->signalmgr.signal_length_cash;
  120. }
  121.  
  122. static void ReportNewPosition(w)
  123. SignalmgrWidget w;
  124. {
  125.   XtCallCallbacks(w, XtNoriginChanged, w->signalmgr.signal_scroll);
  126. }
  127.  
  128. static void RepositionSignals(w, indent)
  129. SignalmgrWidget w;
  130. int indent;
  131. {
  132.     int i;
  133.     for(i=0;i<w->composite.num_children;i++)
  134.       if(XtIsSubclass(w->composite.children[i], signalWidgetClass)){
  135.         XtVaSetValues(w->composite.children[i],
  136.         XtNorigin, w->signalmgr.signal_scroll,
  137.         NULL);
  138.       }
  139. }
  140.  
  141. void SetScrollBarThumb(w)
  142. SignalmgrWidget w;
  143. {
  144.     XawScrollbarSetThumb(w->signalmgr.hscroll,
  145.     w->signalmgr.signal_scroll/(float)length_cash(w),
  146.     (w->core.width/w->signalmgr.time_scale)/(float)length_cash(w));
  147. }
  148.  
  149. void SignalmgrCallbackSetOrigin(w, smw, origin)
  150. Widget w;
  151. SignalmgrWidget smw;
  152. int origin;
  153. {
  154.   smw->signalmgr.signal_scroll = origin;
  155.   RepositionSignals(smw, origin);
  156.   SetScrollBarThumb(smw);
  157. }
  158.  
  159. static void ScrollSignals(sw, w, pos)
  160. ScrollbarWidget sw;
  161. SignalmgrWidget w;
  162. XtPointer pos;
  163. {
  164.     w->signalmgr.signal_scroll +=
  165.     ((int)pos > 0?1:-1)*((2*w->core.width)/(3*w->signalmgr.time_scale));
  166.     if(w->signalmgr.signal_scroll<0)w->signalmgr.signal_scroll = 0;
  167.  
  168.     RepositionSignals(w, w->signalmgr.signal_scroll);
  169.     SetScrollBarThumb(w);
  170.     ReportNewPosition(w);
  171. }
  172.  
  173. static void ScrollSignalsSmooth(sw, w, perc_ptr)
  174. ScrollbarWidget sw;
  175. SignalmgrWidget w;
  176. XtPointer perc_ptr;
  177. {
  178.   float perc = *(float *)perc_ptr;
  179.   int new_scroll = length_cash(w)*perc;
  180.   if(w->signalmgr.signal_scroll != new_scroll){
  181.     w->signalmgr.signal_scroll = new_scroll;
  182.     RepositionSignals(w, w->signalmgr.signal_scroll); 
  183.     ReportNewPosition(w);
  184.   }
  185. }
  186.  
  187. void SignalmgrInitialize(request, new)
  188. SignalmgrWidget request, new;
  189. {
  190.     if(new->core.width==0)new->core.width = 252;
  191.     if(new->core.height==0){
  192.       if(new->signalmgr.widgets_shown==0){
  193.         new->core.height = 275;
  194.       } else { new->core.height = new->signalmgr.widgets_shown * 
  195.       new->signalmgr.label_height + new->signalmgr.scrollbar_width;
  196.       }
  197.     }
  198.     new->signalmgr.geometry_cache.request_mode = (XtGeometryMask)0;
  199.     new->signalmgr.vscroll = XtVaCreateManagedWidget("",
  200.     scrollbarWidgetClass, new,
  201.     XtNorientation, XtorientVertical, NULL);
  202.     XtAddCallback(new->signalmgr.vscroll, XtNscrollProc, Scroll, new);
  203.     new->signalmgr.hscroll = XtVaCreateManagedWidget("",
  204.     scrollbarWidgetClass, new,
  205.     XtNorientation, XtorientHorizontal, NULL);
  206.     XtAddCallback(new->signalmgr.hscroll, XtNscrollProc, ScrollSignals, new);
  207.     XtAddCallback(new->signalmgr.hscroll, XtNjumpProc, ScrollSignalsSmooth, new);
  208.     new->signalmgr.label = XtVaCreateManagedWidget(XtName(new),
  209.     labelWidgetClass, new, NULL);
  210.     new->signalmgr.scroll = 0;
  211.     new->signalmgr.signal_scroll = 0;
  212.     new->signalmgr.time_scale = 1;
  213. };
  214.  
  215. static void SignalmgrResize(w)
  216. SignalmgrWidget w;
  217. {
  218.   do_layout(w);
  219. }
  220.  
  221. static void SignalmgrChangeManaged(w)
  222. SignalmgrWidget w;
  223. {
  224.     do_layout(w);
  225. }
  226.  
  227. #define max(a,b) ((a)>(b)?(a):(b))
  228.  
  229. static void MiniChild(w, width, height)
  230. SignalmgrWidget w;
  231. Dimension *width, *height;
  232. {
  233.   XtWidgetGeometry req, pref;
  234.   pref.width = pref.height = 0;
  235.   pref.request_mode = CWWidth | CWHeight;
  236.   (void) XtQueryGeometry(w, &req, &pref);
  237.   *width = pref.width;
  238.   *height = pref.height;
  239. }
  240.  
  241. static XtGeometryResult SignalmgrQueryGeometry(w, req, pref)
  242. SignalmgrWidget w;
  243. XtWidgetGeometry *req, *pref;
  244. {
  245.   return(XtGeometryNo);
  246. }  
  247.  
  248. static void try_do_layout(w, req)
  249. SignalmgrWidget w;
  250. XtWidgetGeometry *req;
  251. {
  252.     XtWidgetGeometry  pref;
  253.     if(req->width > w->core.width || req->height > w -> core.height){
  254.       (void) XtMakeGeometryRequest(w, req, &pref);
  255.     }
  256.     do_layout(w);
  257. }
  258.  
  259. static void ConfigureBorderedWidget(w, x, y, width, height)
  260. Widget w;
  261. Dimension x, y, width, height;
  262. {
  263.   XtConfigureWidget(w, x, y,
  264.     width - 2*w->core.border_width,
  265.     height - 2*w->core.border_width,
  266.     w->core.border_width);
  267. }
  268.  
  269. static void do_layout(w)
  270. SignalmgrWidget w;
  271. {
  272.   int i;
  273.   Dimension
  274.     a = w->signalmgr.scrollbar_width,
  275.     b = w->signalmgr.label_width,
  276.     g = w->signalmgr.label_height;
  277.   Dimension
  278.     h = a + b,
  279.     d = w->core.height - a;
  280.   Dimension
  281.     c = w->core.width - h;
  282.   Boolean Odd = True;
  283.   int n = 0;
  284.   int visible = d/g;
  285.   int max_n = (w->composite.num_children - 2) / 2;
  286.   
  287.   if(w->signalmgr.scroll>=max_n-visible)w->signalmgr.scroll=max_n-visible;
  288.   if(max_n<visible){
  289.     w->signalmgr.scroll=0;
  290.     XawScrollbarSetThumb(w->signalmgr.vscroll, 1.0, 0.0);
  291.   } else {
  292.     XawScrollbarSetThumb(w->signalmgr.vscroll, w->signalmgr.scroll/(float)max_n, visible/(float)max_n);
  293.   }
  294.   reset_length_cash(w);
  295.   for(i=0; i<w->composite.num_children; i++){
  296.     Widget child = w->composite.children[i];
  297.     if(child->core.managed){
  298.       if(child==w->signalmgr.vscroll){
  299.         ConfigureBorderedWidget(child, 0, 0, a, d);
  300.       } else if(child==w->signalmgr.hscroll){
  301.         ConfigureBorderedWidget(child, h, d, c, a);
  302.       } else if(child==w->signalmgr.label){
  303.         ConfigureBorderedWidget(child, 0, d, h, a);
  304.       } else if(Odd){
  305.         Odd = False;
  306.         if(n>=w->signalmgr.scroll){
  307.         ConfigureBorderedWidget(child, a, (n-w->signalmgr.scroll)*g, b, g);
  308.             if(XtIsRealized(child))XtMapWidget(child);
  309.         } else {
  310.         XtUnmapWidget(child);
  311.         }
  312.       } else {
  313.         Odd = True;
  314.         if(n>=w->signalmgr.scroll){
  315.             ConfigureBorderedWidget(child, h, (n-w->signalmgr.scroll)*g, c, g);
  316.             if(XtIsRealized(child))XtMapWidget(child);
  317.             update_length_cash(w, child);
  318.         } else {
  319.         XtUnmapWidget(child);
  320.         }
  321.         n++;
  322.       }
  323.     }
  324.   }
  325.   SetScrollBarThumb(w);
  326. }
  327.  
  328. static XtGeometryResult SignalmgrGeometryManager(w, ch_req, ch_pref)
  329. Widget w;
  330. XtWidgetGeometry *ch_req, *ch_pref;
  331. {
  332.   return(XtGeometryNo);
  333. }
  334.